﻿<h1>Go中的<code>nil</code></h1>

<p>
<code>nil</code>是Go中的一个使用频率很高的预声明标识符。
很多种类的类型的零值都用<code>nil</code>表示。
很多有其它语言编程经验的程序员在初学Go语言的时候常将<code>nil</code>看成是其它语言中的<code>null</code>或者<code>NULL</code>。
这种看法只是部分上正确的，但是Go中的<code>nil</code>和其它语言中的<code>null</code>或者<code>NULL</code>也是有很大的区别的。
</p>

<p>
本文的剩余部分将列出和<code>nil</code>相关的各种事实。
</p>

<h3><code>nil</code>是一个预声明的标识符</h3>

<p>
我们可以直接使用它。
</p>

<h3>预声明的<code>nil</code>标识符可以表示很多种类型的零值</h3>

<div>
在Go中，预声明的<code>nil</code>可以表示下列种类（kind）的类型的零值：
<ul>
<li>指针类型（包括类型安全和非类型安全指针）</li>
<li>映射类型</li>
<li>切片类型</li>
<li>函数类型</li>
<li>通道类型</li>
<li>接口类型</li>
</ul>

</div>

<h3>预声明标识符<code>nil</code>没有默认类型</h3>

<div>
Go中其它的预声明标识符都有各自的默认类型，比如
<ul>
<li>
	预声明标识符<code>true</code>和<code>false</code>的默认类型均为内置类型<code>bool</code>。
</li>
<li>
	预声明标识符<code>iota</code>的默认类型为内置类型<code>int</code>。
</li>
</ul>

<p>
但是，预声明标识符<code>nil</code>没有一个默认类型，尽管它有很多潜在的可能类型。
事实上，预声明标识符<code>nil</code>是Go中唯一一个没有默认类型的类型不确定值。
我们必须在代码中提供足够的信息以便让编译器能够推断出一个类型不确定的<code>nil</code>值的期望类型。
</p>

一个例子：
<pre class="line-numbers"><code class="language-go">package main

func main() {
	// 代码中必须提供充足的信息来让编译器推断出某个nil的类型。
	_ = (*struct{})(nil)
	_ = []int(nil)
	_ = map[int]bool(nil)
	_ = chan string(nil)
	_ = (func())(nil)
	_ = interface{}(nil)

	// 下面这一组和上面这一组等价。
	var _ *struct{} = nil
	var _ []int = nil
	var _ map[int]bool = nil
	var _ chan string = nil
	var _ func() = nil
	var _ interface{} = nil

	// 下面这行编译不通过。
	var _ = nil
}
</code></pre>
</div>

<h3><code>nil</code>不是一个关键字</h3>

<div>
<p>
预声明标识符<code>nil</code>可以被更内层的同名标识符所遮挡。
</p>

一个例子：
<pre class="line-numbers"><code class="language-go">package main

import "fmt"

func main() {
	nil := 123
	fmt.Println(nil) // 123

	// 下面这行编译报错，因为此行中的nil是一个int值。
	var _ map[string]int = nil
}
</code></pre>

<p><i>
（顺便说一下，其它语言中的<code>null</code>和<code>NULL</code>也不是关键字。）
</i></p>
</div>

<a class="anchor" id="sizes"></a>
<h3>不同种类的类型的nil值的尺寸很可能不相同</h3>

<div>
<p>
一个类型的所有值的内存布局都是一样的，此类型nil值也不例外（假设此类型的零值使用<code>nil</code>表示）。
所以同一个类型的nil值和非nil值的尺寸是一样的。但是不同类型的nil值的尺寸可能是不一样的。
</p>

一个例子：
<pre class="line-numbers"><code class="language-go">package main

import (
	"fmt"
	"unsafe"
)

func main() {
	var p *struct{} = nil
	fmt.Println( unsafe.Sizeof( p ) ) // 8

	var s []int = nil
	fmt.Println( unsafe.Sizeof( s ) ) // 24

	var m map[int]bool = nil
	fmt.Println( unsafe.Sizeof( m ) ) // 8

	var c chan string = nil
	fmt.Println( unsafe.Sizeof( c ) ) // 8

	var f func() = nil
	fmt.Println( unsafe.Sizeof( f ) ) // 8

	var i interface{} = nil
	fmt.Println( unsafe.Sizeof( i ) ) // 16
}
</code></pre>

<p>
</p>

<p>
上例打印出来的尺寸值取决于系统架构和具体编译器实现。
上例中的输出是使用官方标准编译器编译并在64位的系统架构上运行的结果。
在32位的系统架构上，这些输出值将减半。
</p>

<p>
对于官方标准编译器，如果两个类型属于同一种（kind）类型，并且它们的零值用<code>nil</code>表示，则这两个类型的尺寸肯定相等。
</p>
</div>

<h3>两个不同类型的nil值可能不能相互比较</h3>

<div>
比如，下例中的两行中的比较均编译不通过。
<pre class="line-numbers"><code class="language-go">// error: 类型不匹配
var _ = (*int)(nil) == (*bool)(nil)
// error: 类型不匹配
var _ = (chan int)(nil) == (chan bool)(nil)
</code></pre>

<p>
</p>

<p>
请阅读<a href="value-conversions-assignments-and-comparisons.html#comparison-rules">Go中的值比较规则</a>来了解哪些值可以相互比较。
类型确定的nil值也要遵循这些规则。
</p>

下面这些比较是合法的：
<pre class="line-numbers"><code class="language-go">type IntPtr *int
// 类型IntPtr的底层类型为*int。
var _ = IntPtr(nil) == (*int)(nil)

// 任何类型都实现了interface{}类型。
var _ = (interface{})(nil) == (*int)(nil)

// 一个双向通道可以隐式转换为和它的
// 元素类型一样的单项通道类型。
var _ = (chan int)(nil) == (chan<- int)(nil)
var _ = (chan int)(nil) == (<-chan int)(nil)
</code></pre>
</div>

<h3>同一个类型的两个nil值可能不能相互比较</h3>

<div>
在Go中，映射类型、切片类型和函数类型是不支持比较类型。
比较同一个不支持比较的类型的两个值（包括nil值）是非法的。
比如，下面的几个比较都编译不通过。
<pre class="line-numbers"><code class="language-go">var _ = ([]int)(nil) == ([]int)(nil)
var _ = (map[string]int)(nil) == (map[string]int)(nil)
var _ = (func())(nil) == (func())(nil)
</code></pre>

但是，映射类型、切片类型和函数类型的任何值都可以和类型不确定的裸<code>nil</code>标识符比较。
<pre class="line-numbers"><code class="language-go">// 这几行编译都没问题。
var _ = ([]int)(nil) == nil
var _ = (map[string]int)(nil) == nil
var _ = (func())(nil) == nil
</code></pre>
</div>

<h3>两个nil值可能并不相等</h3>

<div>
<p>
如果可被比较的两个nil值中的一个的类型为接口类型，而另一个不是，则比较结果总是<code>false</code>。
原因是，在进行此比较之前，此非接口nil值将被转换为另一个nil值的接口类型，从而将此比较转化为两个接口值的比较。
从<a href="interface.html#boxing">接口</a>一文中，我们得知每个接口值可以看作是一个包裹非接口值的盒子。
一个非接口值被转换为一个接口类型的过程可以看作是用一个接口值将此非接口值包裹起来的过程。
一个nil接口值中什么也没包裹，但是一个包裹了nil非接口值的接口值并非什么都没包裹。
一个什么都没包裹的接口值和一个包裹了一个非接口值（即使它是nil）的接口值是不相等的。
</p>

一个例子：
<pre class="line-numbers"><code class="language-go">fmt.Println( (interface{})(nil) == (*int)(nil) ) // false
</code></pre>
</div>

<h3>访问nil映射值的条目不会产生恐慌</h3>

<div>
<p>
访问一个nil映射将得到此映射的类型的元素类型的零值。
</p>

比如：
<pre class="line-numbers"><code class="language-go">fmt.Println( (map[string]int)(nil)["key"] ) // 0
fmt.Println( (map[int]bool)(nil)[123] )     // false
fmt.Println( (map[int]*int64)(nil)[123] )   // &lt;nil&gt;
</code></pre>
</div>

<h3><code>range</code>关键字后可以跟随nil通道、nil映射、nil切片和nil数组指针</h3>

<div>
<p>
遍历nil映射和nil切片的循环步数均为零。
</p>

<p>
遍历一个nil数组指针的循环步数为对应数组类型的长度。
（但是，如果此数组类型的长度不为零并且第二个循环变量未被舍弃或者忽略，则对应<code>for-range</code>循环将导致一个恐慌。）
</p>

<p>
遍历一个nil通道将使当前协程永久阻塞。
</p>

比如，下面的代码将输出<code>0</code>、<code>1</code>、<code>2</code>、<code>3</code>和<code>4</code>后进入阻塞状态。
<code>Hello</code>、<code>world</code>和<code>Bye</code>不会被输出。
<pre class="line-numbers"><code class="language-go">for range []int(nil) {
	fmt.Println("Hello")
}

for range map[string]string(nil) {
	fmt.Println("world")
}

for i := range (*[5]int)(nil) {
	fmt.Println(i)
}

for range chan bool(nil) { // 阻塞在此
	fmt.Println("Bye")
}
</code></pre>
</div>

<h3>通过nil非接口属主实参调用方法不会造成恐慌</h3>

<div>
一个例子：
<pre class="line-numbers"><code class="language-go">package main

type Slice []bool

func (s Slice) Length() int {
	return len(s)
}

func (s Slice) Modify(i int, x bool) {
	s[i] = x // panic if s is nil
}

func (p *Slice) DoNothing() {
}

func (p *Slice) Append(x bool) {
	*p = append(*p, x) // 如果p为空指针，则产生一个恐慌。
}

func main() {
	// 下面这几行中的选择器不会造成恐慌。
	_ = ((Slice)(nil)).Length
	_ = ((Slice)(nil)).Modify
	_ = ((*Slice)(nil)).DoNothing
	_ = ((*Slice)(nil)).Append

	// 这两行也不会造成恐慌。
	_ = ((Slice)(nil)).Length()
	((*Slice)(nil)).DoNothing()

	// 下面这两行都会造成恐慌。但是恐慌不是因为nil
	// 属主实参造成的。恐慌都来自于这两个方法内部的
	// 对空指针的解引用操作。
	/*
	((Slice)(nil)).Modify(0, true)
	((*Slice)(nil)).Append(true)
	*/
}
</code></pre>

<p>
</p>

事实上，上面的<code>Append</code>方法实现不完美。我们应该像下面这样实现之：

<pre class="line-numbers"><code class="language-go">func (p *Slice) Append(x bool) {
	if p == nil {
		*p = []bool{x}
		return
	}
	*p = append(*p, x)
}
</code></pre>

<p>
</p>
</div>

<h3>如果类型<code>T</code>的零值可以用预声明的<code>nil</code>标识符表示，则<code>*new(T)</code>的估值结果为一个<code>T</code>类型的nil值</h3>

<div>
一个例子：
<pre class="line-numbers"><code class="language-go">package main

import "fmt"

func main() {
	fmt.Println(*new(*int) == nil)         // true
	fmt.Println(*new([]int) == nil)        // true
	fmt.Println(*new(map[int]bool) == nil) // true
	fmt.Println(*new(chan string) == nil)  // true
	fmt.Println(*new(func()) == nil)       // true
	fmt.Println(*new(interface{}) == nil)  // true
}
</code></pre>
</div>

<h3>总结一下</h3>

<p>
在Go中，为了简单和方便，<code>nil</code>被设计成一个可以表示成很多种类型的零值的预声明标识符。
换句话说，它可以表示很多内存布局不同的值，而不仅仅是一个值。
</p>
